{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "8. Antiderivative(Physics-Informed-DeepONet).ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jdtoscano94/Learning-PINNs-in-Python-Physics-Informed-Machine-Learning/blob/main/8_Antiderivative(Physics_Informed_DeepONet).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7JQXTWz35c40"
      },
      "outputs": [],
      "source": [
        "import numpy as onp\n",
        "import jax.numpy as np\n",
        "from jax import random, grad, vmap, jit\n",
        "from jax.experimental import optimizers\n",
        "from jax.experimental.ode import odeint\n",
        "from jax.nn import relu\n",
        "from jax.config import config\n",
        "\n",
        "import itertools\n",
        "from functools import partial\n",
        "from torch.utils import data\n",
        "from tqdm import trange\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Auxiliary Functions"
      ],
      "metadata": {
        "id": "fDhK-Kr3GyGa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define RBF kernel\n",
        "def RBF(x1, x2, params):\n",
        "    output_scale, lengthscales = params\n",
        "    diffs = np.expand_dims(x1 / lengthscales, 1) - \\\n",
        "            np.expand_dims(x2 / lengthscales, 0)\n",
        "    r2 = np.sum(diffs**2, axis=2)\n",
        "    return output_scale * np.exp(-0.5 * r2)"
      ],
      "metadata": {
        "id": "rT2DnjCLG3cv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def plot_us(x,u,y,s):\n",
        "  fig, ax1 = plt.subplots(figsize=(8, 6))\n",
        "  plt.rcParams['font.size'] = '18'\n",
        "  color='black'\n",
        "  wdt=1.5\n",
        "  ax1.plot(x,u,'k--',label='$u(x)=ds/dx$',linewidth=wdt)\n",
        "  ax1.plot(y,s,'o-',label='$s(x)=s(0)+\\int u(t)dt|_{t=y}$',linewidth=wdt)\n",
        "  ax1.set_xlabel('x',fontsize='large')\n",
        "  ax1.set_ylabel('u',fontsize='large')\n",
        "  ax1.tick_params(axis='y', color=color)\n",
        "  ax1.legend(loc = 'lower right', ncol=1)"
      ],
      "metadata": {
        "id": "IVsow-L9Gz2b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Introduction**\n",
        "\n",
        "## **Functions and Operators:**\n",
        "\n",
        "### **Function:**\n",
        "\n",
        " Maps between vector spaces:\n",
        "\n",
        "*Example:*\n",
        "\n",
        "Let $f_1(x)=sin(x)$; for  $x\\in\\mathbf{R}$\n",
        "\n",
        "$$z=f_1(x)=sin(x)\\in[0:1]$$\n",
        "\n",
        "In other words $f_1$ maps $\\mathbf{R}→[0,1]$\n",
        "\n",
        "### **Operator:**\n",
        "\n",
        " Maps between infinite-dimensional function spaces:\n",
        "$$G(f_1(x))=f_2(x)$$\n",
        "\n",
        "*Example:*\n",
        "\n",
        "Derivative Operator →$\\frac{d}{d x}$\n",
        "\n",
        "It transforms a funcion $f_1$ into a function $f_2$:\n",
        "\n",
        "Let $f_1(x)=sin(x)$\n",
        "\n",
        "Then when we apply our operator:\n",
        "\n",
        "$$f_2=\\frac{df_1(x)}{d x}=\\frac{d}{d x}sin(x)=cos(x)$$\n",
        "\n",
        "\n",
        "### **Parametric PDEs and Operators**\n",
        "\n",
        "Parametric PDEs $\\rightarrow$ Some parameters (e.g., shape, IC/BC, coefficients, etc.) of a given PDE system are allowed to change.\n",
        "\n",
        "Let  $\\mathcal{N}$ be a nonlinear differential operator. Let's consider parametric PDEs of the form:\n",
        "\n",
        "$$\\mathcal{N}(u,s)=0$$\n",
        "\n",
        "where, $u$ is the input function, and $s$ is the unknown PDE's solution (also a function.)\n",
        "\n",
        "Our PDE solution operator would be:\n",
        "\n",
        "$$G(u)=s$$\n",
        "\n",
        "**Note 1:**In other words, we can express the general solution of our PDE as an operator $G$\n",
        "\n",
        "**Note 2:** Remember $s$ is itself a function, so if we evaluate it at any point $y$, the answer would be a real number:\n",
        "\n",
        " $$G(u)(y)=s(y)\\in \\mathbf{R}$$\n",
        "\n",
        " ### **Universal Approximation Theorem for Operator**\n",
        "\n",
        " $\\forall \\epsilon >0$, there are positive integers $n,p,m$, constants $c_i^k,W_{bij}^k,b_{bij}^k,W_{tk},b_{tk}$ such that:\n",
        "\n",
        "$$\\left|G(u)(y)-\\sum_{k=1}^{p}\\sum_{i=1}^{n}c_i^k\\sigma\\left(\\sum_{j=1}^{m}W_{bij}^{k}u(x_j)+b_{bi}^k\\right).\\sigma(W_{tk}.y+b_{tk})\\right|<\\epsilon $$\n",
        "\n",
        " ### **Neural Network**\n",
        "\n",
        "A Neural Network is a function that takes the form: (See:https://book.sciml.ai/notes/03/)\n",
        "\n",
        "$$NN(X)=W_n\\sigma_{n-1}(W_{n-1}\\sigma_{n-2}(...(W_2\\sigma_1(W_1X+b_1)+b_2)+..)+b_{n-1})+b_n$$\n",
        "\n",
        "So we can use 2 NNs to implement the Universal Approximation Theorem for Operator i.e.\n",
        "\n",
        "Branch:\n",
        "\n",
        "$$NN_b(u(\\textbf{x}))=b(u(\\textbf{x}))=\\textbf{c}.\\sigma\\left(W_{b}u(\\textbf{x})+\\textbf{b}_{b}\\right)$$\n",
        "\n",
        "Trunk:\n",
        "\n",
        "\n",
        "$$NN_t(\\textbf{y})=t(\\textbf{y})=\\sigma(W_{t}.\\textbf{y}+\\textbf{b}_{t})$$\n",
        "\n",
        "### **DeepOnet**\n",
        "\n",
        "Learn the solution operators of parametric PDEs → We will try to approximate $G$  (the solution of our PDE operator) by two neural networks:\n",
        "\n",
        "\n",
        "$$G_\\theta(u)(y)=\\sum_{k=1}^q\\underset{Branch}{\\underbrace{b_k\\left(u(x_1),u(x_2),...,u(x_m)\\right)}}.\\underset{Trunk}{\\underbrace{t_k(\\textbf{y})}}$$\n",
        "\n",
        "\n",
        "We want to obtain G, so our goal would be:\n",
        "\n",
        " $$G_\\theta(u)(y)\\approx G(u)(y)$$\n",
        "\n",
        "So we will enforce that condition into a loss function:\n",
        "\n",
        "$$\\mathcal{L}_{Operator}(\\theta)=\\frac{1}{NP}\\sum_{i=1}^N\\sum_{j=1}^P\\left|G_{\\theta}(u^{(i)})y_j^{(i)}-G(u^{(i)})y_j^{(i)}\\right|^2$$\n",
        "\n",
        "\n",
        "$$\\mathcal{L}_{Operator}(\\theta)=\\frac{1}{NP}\\sum_{i=1}^N\\sum_{j=1}^P\\left|\\sum_{k=1}^q{b_k\\left(u(x_1),u(x_2),...,u(x_m)\\right)}.t_k(y_j^{(i)})-G(u^{(i)})y_j^{(i)}\\right|^2$$\n",
        "\n",
        "where $N$ is the number of functions $u(x)$ in our training dataset, $P$ is the number of points inside the domain at which we will evaluate $G(u)$. \n",
        "\n",
        "$m:$ Number of points at which we evaluated our input functions.\n",
        "\n",
        "$N:$ Number of input functions.\n",
        "\n",
        "$P:$ Number of points at which we evaluate the output function → output sensors.\n"
      ],
      "metadata": {
        "id": "PhPIO4gwxTcb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Physics-informed DeepONets\n",
        "\n",
        "\n",
        "Similar to a PINN, a Physics-informed DeepONets output functions consistent with physical constraints by minimizing the residual of an underlying governing law (i.e., nonlinear differential operator).\n",
        "\n",
        "$$\\mathcal{L}_{Physics}(\\theta)=\\frac{1}{NQm}\\sum_{i=1}^{N}\\sum_{j=1}^{Q}\\sum_{k=1}^{m}\\left|\\mathcal{N}(u^{(i)}(x_k),G_{\\theta}(u^{(i)})(y_j^{(i)})\\right|^2$$\n",
        "\n",
        "where $\\mathcal{N}$ is a nonlinear differential operator, and $\\{y_j\\}_{i=1}^{Q}$ are the collocation points ( we use them to enforce the physical constraint).\n",
        "\n",
        "So the total loss would be:\n",
        "\n",
        "$$\\mathcal{L}(\\theta)=\\mathcal{L}_{Operator}(\\theta)+\\mathcal{L}_{Physics}(\\theta)$$\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "uRXrweOQ7JRL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**In summary:**\n",
        "\n",
        "To train a DeepOnet, we would:\n",
        "\n",
        "1.   We select $N$ functions →$u^{(i)}(x)$.\n",
        "2.   We evaluate our $N$ functions at $m$ points (i.e., input sensors) →$\\begin{bmatrix}u^{(1)}(x_1)&u^{(1)}(x_2)&...&u^{(1)}(x_m)\\\\\n",
        "u^{(2)}(x_1)&u^{(2)}(x_2)&...&u^{(2)}(x_m)\\\\\n",
        "\\vdots&\\vdots&\\ddots&\\vdots\\\\\n",
        "u^{(N)}(x_1)&u^{(N)}(x_2)&...&u^{(N)}(x_m)\\end{bmatrix}$\n",
        "3.   We send the $m$ outputs of our $N$ functions to our **branch network** → $b_k\\begin{pmatrix}u^{(1)}(x_1)&u^{(1)}(x_2)&...&u^{(1)}(x_m)\\\\\n",
        "u^{(2)}(x_1)&u^{(2)}(x_2)&...&u^{(2)}(x_m)\\\\\n",
        "\\vdots&\\vdots&\\ddots&\\vdots\\\\\n",
        "u^{(N)}(x_1)&u^{(N)}(x_2)&...&u^{(N)}(x_m)\\end{pmatrix}$\n",
        "4.   We select $P$ points (i.e., output sensors) inside our domain → $y_1,y_2,...,y_P$\n",
        "5.  We send our output sensors to our **trunk network**→$t_k(y_1,y_2,...,y_P)$\n",
        "6. We approximate our operator by computing the dot product between the output of our **branch network** and the output of our **trunk network**→ $G_\\theta(u)(y)=\\sum_{k=1}^q\\underset{Branch}{\\underbrace{b_k\\left(u(x_1),u(x_2),...,u(x_m)\\right)}}.\\underset{Trunk}{\\underbrace{t_k(\\textbf{y})}}$\n",
        "7. Ideally $G_\\theta(u)(y)\\approx G(u)(y)$, so we compute the error → $\\mathcal{L}_{Operator}(\\theta)=\\frac{1}{NP}\\sum_{i=1}^N\\sum_{j=1}^P\\left|G_{\\theta}(u^{(i)})y_j^{(i)}-G(u^{(i)})y_j^{(i)}\\right|^2$\n",
        "8. We compute the error related to the underlying governing laws→ $\\mathcal{L}_{Physics}(\\theta)=\\frac{1}{NQm}\\sum_{i=1}^{N}\\sum_{j=1}^{Q}\\sum_{k=1}^{m}\\left|\\mathcal{N}(u^{(i)}(x_k),G_{\\theta}(u^{(i)})(y_j^{(i)})\\right|^2$\n",
        "\n",
        "9. We compute the total loss→$\\mathcal{L}(\\theta)=\\mathcal{L}_{operator}(\\theta)+\\mathcal{L}_{Physics}(\\theta)$\n",
        "9. We update our NN parameters (i.e., branch and trunk) to minimize  $\\mathcal{L}(\\theta)$.\n",
        "10. We repeat the process."
      ],
      "metadata": {
        "id": "Ps79-_vKBzDC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Problem Setup\n",
        "\n",
        "**Anti-derivative Operator**\n",
        "\n",
        "Our PDE would be:\n",
        "\n",
        "$$\\frac{ds(x)}{dx}-u(x)=0$$\n",
        "\n",
        "\n",
        "The solution of our PDE is:\n",
        "\n",
        "$$G:u(x)→s(x)=s(0)+\\int_{0}^{x}u(t)dt$$\n",
        "\n",
        "$$x\\in[0,1]$$\n",
        "$$s(0)=0$$\n",
        "\n",
        "In this example, lets concider $Q=m$ and $\\{y_j^{(i)}\\}_{j=1}^Q$. Hence, the physics loss can be formulated as:\n",
        "\n",
        "$$\\mathcal{L}_{Physics}(\\theta)=\\frac{1}{Nm}\\sum_{i=1}^{N}\\sum_{k=1}^{m}\\left|\\frac{dG_{\\theta}(u^{(i)})(y)}{dy}\\big{|}_{y=x_j}-u^{(i)}(x_j)\\right|^2$$\n"
      ],
      "metadata": {
        "id": "J-qnbwQ5DTuw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Data Generation"
      ],
      "metadata": {
        "id": "FvY9PrxfylwH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We will randomly sample 10000 different functions $u$ from a zero-mean Gaussian process with an exponential quadratic kernel with a length scale: $l=0.2$."
      ],
      "metadata": {
        "id": "phC4C1GNDrvA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "N_train = 10000\n",
        "m = 100 # number of input sensors\n",
        "P_train = 1   # number of output sensors\n",
        "length_scale = 0.2 #lenght_scale for the exponential quadratic kernel\n",
        "key_train = random.PRNGKey(0)  # use different key for generating training data and test data \n",
        "config.update(\"jax_enable_x64\", True) # Enable double precision"
      ],
      "metadata": {
        "id": "R-lQbo2kYcvA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Generate a random function"
      ],
      "metadata": {
        "id": "gupNZ3GKDSDu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Sample GP prior at a fine grid\n",
        "N = 512\n",
        "gp_params = (1.0, length_scale)\n",
        "jitter = 1e-10\n",
        "X = np.linspace(0, 1, N)[:,None]\n",
        "K = RBF(X, X, gp_params)\n",
        "L = np.linalg.cholesky(K + jitter*np.eye(N))\n",
        "gp_sample = np.dot(L, random.normal(key_train, (N,)))\n",
        "\n",
        "# Create a callable interpolation function  \n",
        "u_fn = lambda x, t: np.interp(t, X.flatten(), gp_sample)\n",
        "# Input sensor locations and measurements\n",
        "x = np.linspace(0, 1, m)\n",
        "u = vmap(u_fn, in_axes=(None,0))(0.0, x) #vectorize our code to run it in multiple batches simultaneusly (or to evaluate a function simultaneusly)"
      ],
      "metadata": {
        "id": "ol-umrOeGD0E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We obtain the corresponding 10000 ODE solutions by solving: \n",
        "\n",
        "$$\\frac{ds(x)}{dx}=u(x)$$\n",
        "\n",
        "Using an explicit Runge-Kutta method(RK45)→ JAX's odeint functiom."
      ],
      "metadata": {
        "id": "XHzsz9XlEzCy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Output sensor locations and measurements\n",
        "y_train = random.uniform(key_train, (P_train*100,)).sort() \n",
        "s_train = odeint(u_fn, 0.0, y_train) # Obtain the ODE solution"
      ],
      "metadata": {
        "id": "Y6-OyfHJl0-7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot_us(x,u,y_train,s_train)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 400
        },
        "id": "kTiLiL5gK917",
        "outputId": "e876c480-3351-41aa-8f2d-044ec566f5a8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, we will have to create many functions for our testing and training dataset, so let's create a pair of programing-functions to generate one random function at a time."
      ],
      "metadata": {
        "id": "0BJmeBjxfjjg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Geneate training data corresponding to one input sample\n",
        "def generate_one_training_data(key, m=100, P=1):\n",
        "    # Sample GP prior at a fine grid\n",
        "    N = 512\n",
        "    gp_params = (1.0, length_scale)\n",
        "    jitter = 1e-10\n",
        "    X = np.linspace(0, 1, N)[:,None]\n",
        "    K = RBF(X, X, gp_params)\n",
        "    L = np.linalg.cholesky(K + jitter*np.eye(N))\n",
        "    gp_sample = np.dot(L, random.normal(key, (N,)))\n",
        "\n",
        "    # Create a callable interpolation function  \n",
        "    u_fn = lambda x, t: np.interp(t, X.flatten(), gp_sample)\n",
        "\n",
        "    # Input sensor locations and measurements\n",
        "    x = np.linspace(0, 1, m)\n",
        "    u = vmap(u_fn, in_axes=(None,0))(0.0, x)\n",
        "\n",
        "    # Output sensor locations and measurements\n",
        "    y_train = random.uniform(key, (P,)).sort() \n",
        "    s_train = odeint(u_fn, 0.0, np.hstack((0.0, y_train)))[1:] # JAX has a bug and always returns s(0), so add a dummy entry to y and return s[1:]\n",
        "\n",
        "    # Tile inputs\n",
        "    u_train = np.tile(u, (P,1))\n",
        "\n",
        "    # training data for the residual\n",
        "    u_r_train = np.tile(u, (m, 1))\n",
        "    y_r_train = x\n",
        "    s_r_train = u\n",
        "\n",
        "    return u_train, y_train, s_train, u_r_train, y_r_train,  s_r_train"
      ],
      "metadata": {
        "id": "aS4wnXKpzHic"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Geneate test data corresponding to one input sample\n",
        "def generate_one_test_data(key, m=100, P=100):\n",
        "    # Sample GP prior at a fine grid\n",
        "    N = 512\n",
        "    gp_params = (1.0, length_scale)\n",
        "    jitter = 1e-10\n",
        "    X = np.linspace(0, 1, N)[:,None]\n",
        "    K = RBF(X, X, gp_params)\n",
        "    L = np.linalg.cholesky(K + jitter*np.eye(N))\n",
        "    gp_sample = np.dot(L, random.normal(key, (N,)))\n",
        "\n",
        "    # Create a callable interpolation function  \n",
        "    u_fn = lambda x, t: np.interp(t, X.flatten(), gp_sample)\n",
        "\n",
        "    # Input sensor locations and measurements\n",
        "    x = np.linspace(0, 1, m)\n",
        "    u = vmap(u_fn, in_axes=(None,0))(0.0, x)\n",
        "\n",
        "    # Output sensor locations and measurements\n",
        "    y = np.linspace(0, 1, P)\n",
        "    s = odeint(u_fn, 0.0, y)\n",
        "\n",
        "    # Tile inputs\n",
        "    u = np.tile(u, (P,1))\n",
        "\n",
        "    return u, y, s "
      ],
      "metadata": {
        "id": "Bhn_Dy-FWph0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Data Generation"
      ],
      "metadata": {
        "id": "rx2GnFcxy2vq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Training Data\n",
        "N_train = 10000 #Number of functions\n",
        "m = 100 # number of input sensors\n",
        "P_train = 1   # number of output sensors\n",
        "key_train = random.PRNGKey(0)  # use different key for generating training data and test data "
      ],
      "metadata": {
        "id": "dKqeYeFVbmEJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "config.update(\"jax_enable_x64\", True) # Enable double precision\n",
        "keys = random.split(key_train, N_train) # Obtain 10000 random numbers"
      ],
      "metadata": {
        "id": "LctcnSb_hVr2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "gen_fn = jit(lambda key: generate_one_training_data(key, m, P_train)) # Call the function that generates functions\n",
        "u_train, y_train, s_train, u_r_train, y_r_train, s_r_train = vmap(gen_fn)(keys)"
      ],
      "metadata": {
        "id": "CZCfAP7Qha8N"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Reshape the data\n",
        "u_train = np.float32(u_train.reshape(N_train * P_train,-1))\n",
        "y_train = np.float32(y_train.reshape(N_train * P_train,-1))\n",
        "s_train = np.float32(s_train.reshape(N_train * P_train,-1))\n",
        "\n",
        "u_r_train = np.float32(u_r_train.reshape(N_train * m,-1))\n",
        "y_r_train = np.float32(y_r_train.reshape(N_train * m,-1))\n",
        "s_r_train = np.float32(s_r_train.reshape(N_train * m,-1))"
      ],
      "metadata": {
        "id": "PrIKONnAiLBs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Testing Data\n",
        "N_test = 1 # number of input samples \n",
        "P_test = m   # number of sensors \n",
        "key_test = random.PRNGKey(12345) # A different key "
      ],
      "metadata": {
        "id": "t72zeQnJirdA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "keys = random.split(key_test, N_test)\n",
        "gen_fn = jit(lambda key: generate_one_test_data(key, m, P_test))\n",
        "u, y, s = vmap(gen_fn)(keys)"
      ],
      "metadata": {
        "id": "EfTydf5Cjkrh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Reshape the data\n",
        "u_test = np.float32(u.reshape(N_test * P_test,-1))\n",
        "y_test = np.float32(y.reshape(N_test * P_test,-1))\n",
        "s_test = np.float32(s.reshape(N_test * P_test,-1))"
      ],
      "metadata": {
        "id": "O_cXqtdFjo57"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Data generator\n",
        "class DataGenerator(data.Dataset):\n",
        "    def __init__(self, u, y, s, \n",
        "                 batch_size=64, rng_key=random.PRNGKey(1234)):\n",
        "        'Initialization'\n",
        "        self.u = u # input sample\n",
        "        self.y = y # location\n",
        "        self.s = s # labeled data evulated at y (solution measurements, BC/IC conditions, etc.)\n",
        "        \n",
        "        self.N = u.shape[0]\n",
        "        self.batch_size = batch_size\n",
        "        self.key = rng_key\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        'Generate one batch of data'\n",
        "        self.key, subkey = random.split(self.key)\n",
        "        inputs, outputs = self.__data_generation(subkey)\n",
        "        return inputs, outputs\n",
        "\n",
        "    @partial(jit, static_argnums=(0,))\n",
        "    def __data_generation(self, key):\n",
        "        'Generates data containing batch_size samples'\n",
        "        idx = random.choice(key, self.N, (self.batch_size,), replace=False)\n",
        "        s = self.s[idx,:]\n",
        "        y = self.y[idx,:]\n",
        "        u = self.u[idx,:]\n",
        "        # Construct batch\n",
        "        inputs = (u, y)\n",
        "        outputs = s\n",
        "        return inputs, outputs"
      ],
      "metadata": {
        "id": "fm6kLyH0lev8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# DeepOnet"
      ],
      "metadata": {
        "id": "GfgoQuM6lKTa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the neural net\n",
        "def MLP(layers, activation=relu):\n",
        "  ''' Vanilla MLP'''\n",
        "  def init(rng_key):\n",
        "      def init_layer(key, d_in, d_out):\n",
        "          k1, k2 = random.split(key)\n",
        "          glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)\n",
        "          W = glorot_stddev * random.normal(k1, (d_in, d_out))\n",
        "          b = np.zeros(d_out)\n",
        "          return W, b\n",
        "      key, *keys = random.split(rng_key, len(layers))\n",
        "      params = list(map(init_layer, keys, layers[:-1], layers[1:]))\n",
        "      return params\n",
        "  def apply(params, inputs):\n",
        "      for W, b in params[:-1]:\n",
        "          outputs = np.dot(inputs, W) + b\n",
        "          inputs = activation(outputs)\n",
        "      W, b = params[-1]\n",
        "      outputs = np.dot(inputs, W) + b\n",
        "      return outputs\n",
        "  return init, apply\n"
      ],
      "metadata": {
        "id": "Jslem3iHlwAs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the model\n",
        "class PI_DeepONet:\n",
        "    def __init__(self, branch_layers, trunk_layers):    \n",
        "        # Network initialization and evaluation functions\n",
        "        self.branch_init, self.branch_apply = MLP(branch_layers, activation=np.tanh)\n",
        "        self.trunk_init, self.trunk_apply = MLP(trunk_layers, activation=np.tanh)\n",
        "\n",
        "        # Initialize\n",
        "        branch_params = self.branch_init(rng_key = random.PRNGKey(1234))\n",
        "        trunk_params = self.trunk_init(rng_key = random.PRNGKey(4321))\n",
        "        params = (branch_params, trunk_params)\n",
        "\n",
        "        # Use optimizers to set optimizer initialization and update functions\n",
        "        self.opt_init, \\\n",
        "        self.opt_update, \\\n",
        "        self.get_params = optimizers.adam(optimizers.exponential_decay(1e-3, \n",
        "                                                                      decay_steps=1000, \n",
        "                                                                      decay_rate=0.9))\n",
        "        self.opt_state = self.opt_init(params)\n",
        "\n",
        "        self.itercount = itertools.count()\n",
        "        \n",
        "        # Loggers\n",
        "        self.loss_log = []\n",
        "        self.loss_operator_log = []\n",
        "        self.loss_physics_log = []\n",
        "\n",
        "    # Define DeepONet architecture\n",
        "    def operator_net(self, params, u, y):\n",
        "        branch_params, trunk_params = params\n",
        "        B = self.branch_apply(branch_params, u)\n",
        "        T = self.trunk_apply(trunk_params, y)\n",
        "        outputs = np.sum(B * T)\n",
        "        return outputs\n",
        "    \n",
        "    # Define ODE/PDE residual\n",
        "    def residual_net(self, params, u, y):\n",
        "        s_y = grad(self.operator_net, argnums = 2)(params, u, y)\n",
        "        return s_y\n",
        "    \n",
        "    # Define operator loss\n",
        "    def loss_operator(self, params, batch):\n",
        "        # Fetch data\n",
        "        # inputs: (u, y), shape = (N, m), (N,1)\n",
        "        # outputs: s, shape = (N,1)\n",
        "        inputs, outputs = batch\n",
        "        u, y = inputs\n",
        "        # Compute forward pass\n",
        "        pred = vmap(self.operator_net, (None, 0, 0))(params, u, y)\n",
        "        # Compute loss\n",
        "        loss = np.mean((outputs.flatten() - pred.flatten())**2)\n",
        "        return loss\n",
        "\n",
        "    # Define physics loss\n",
        "    def loss_physics(self, params, batch):\n",
        "        # Fetch data\n",
        "        # inputs: (u_r, y_r), shape = (NxQ, m), (NxQ,1)\n",
        "        # outputs: s_r, shape = (NxQ, 1)\n",
        "        inputs, outputs = batch\n",
        "        u, y = inputs\n",
        "        # Compute forward pass\n",
        "        pred = vmap(self.residual_net, (None, 0, 0))(params, u, y)\n",
        "        # Compute loss\n",
        "        loss = np.mean((outputs.flatten() - pred.flatten())**2)\n",
        "        return loss    \n",
        "    \n",
        "    # Define total loss\n",
        "    def loss(self, params, operator_batch, physics_batch):\n",
        "        loss_operator = self.loss_operator(params, operator_batch)\n",
        "        loss_physics = self.loss_physics(params, physics_batch)\n",
        "        loss = loss_operator + loss_physics\n",
        "        return loss\n",
        "\n",
        "    # Define a compiled update step\n",
        "    @partial(jit, static_argnums=(0,))\n",
        "    def step(self, i, opt_state, operator_batch, physics_batch):\n",
        "        params = self.get_params(opt_state)\n",
        "        g = grad(self.loss)(params, operator_batch, physics_batch)\n",
        "        return self.opt_update(i, g, opt_state)\n",
        "\n",
        "    # Optimize parameters in a loop\n",
        "    def train(self, operator_dataset, physics_dataset, nIter = 10000):\n",
        "        # Define the data iterator\n",
        "        operator_data = iter(operator_dataset)\n",
        "        physics_data = iter(physics_dataset)\n",
        "\n",
        "        pbar = trange(nIter)\n",
        "        # Main training loop\n",
        "        for it in pbar:\n",
        "            operator_batch= next(operator_data)\n",
        "            physics_batch = next(physics_data)\n",
        "\n",
        "            self.opt_state = self.step(next(self.itercount), self.opt_state, operator_batch, physics_batch)\n",
        "            \n",
        "            if it % 100 == 0:\n",
        "                params = self.get_params(self.opt_state)\n",
        "\n",
        "                # Compute losses\n",
        "                loss_value = self.loss(params, operator_batch, physics_batch)\n",
        "                loss_operator_value = self.loss_operator(params, operator_batch)\n",
        "                loss_physics_value = self.loss_physics(params, physics_batch)\n",
        "\n",
        "                # Store losses\n",
        "                self.loss_log.append(loss_value)\n",
        "                self.loss_operator_log.append(loss_operator_value)\n",
        "                self.loss_physics_log.append(loss_physics_value)\n",
        "\n",
        "                # Print losses during training\n",
        "                pbar.set_postfix({'Loss': loss_value, \n",
        "                                  'loss_operator' : loss_operator_value, \n",
        "                                  'loss_physics': loss_physics_value})\n",
        "       \n",
        "           \n",
        "    # Evaluates predictions at test points  \n",
        "    @partial(jit, static_argnums=(0,))\n",
        "    def predict_s(self, params, U_star, Y_star):\n",
        "        s_pred = vmap(self.operator_net, (None, 0, 0))(params, U_star, Y_star)\n",
        "        return s_pred\n",
        "\n",
        "    @partial(jit, static_argnums=(0,))\n",
        "    def predict_s_y(self, params, U_star, Y_star):\n",
        "        s_y_pred = vmap(self.residual_net, (None, 0, 0))(params, U_star, Y_star)\n",
        "        return s_y_pred"
      ],
      "metadata": {
        "id": "7ZG1bVnij-bg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Evaluate our Operator"
      ],
      "metadata": {
        "id": "p1bmvbf1rTx2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Initialize model\n",
        "# For vanilla DeepONet, shallower network yields better accuarcy.\n",
        "branch_layers = [m, 50, 50, 50, 50, 50]\n",
        "trunk_layers =  [1, 50, 50, 50, 50, 50]\n",
        "\n",
        "model = PI_DeepONet(branch_layers, trunk_layers)"
      ],
      "metadata": {
        "id": "X5RUVLmalT4P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create data set\n",
        "batch_size = 10000\n",
        "operator_dataset = DataGenerator(u_train, y_train, s_train, batch_size)\n",
        "physics_dataset = DataGenerator(u_r_train, y_r_train, s_r_train, batch_size)"
      ],
      "metadata": {
        "id": "vrXXP3ztlun6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Train\n",
        "model.train(operator_dataset, physics_dataset, nIter=40000)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mUDa7cAdl9wR",
        "outputId": "13fba731-61c2-4c3f-ce78-ef68fee99249"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 40000/40000 [31:15<00:00, 21.32it/s, Loss=3.2560986358452726e-05, loss_operator=9.529131720905634e-07, loss_physics=3.1608073e-05]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Predict\n",
        "params = model.get_params(model.opt_state)"
      ],
      "metadata": {
        "id": "eXwnbxoQmR5w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s_pred = model.predict_s(params, u_test, y_test)[:,None]"
      ],
      "metadata": {
        "id": "-nO5cCL6mV-F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s_y_pred = model.predict_s_y(params, u_test, y_test) # remember that s_y=ds/dy=u"
      ],
      "metadata": {
        "id": "NelrdvVvmXPN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Compute relative l2 error\n",
        "error_s = np.linalg.norm(s_test - s_pred) / np.linalg.norm(s_test) \n",
        "error_u = np.linalg.norm(u_test[::P_test].flatten()[:,None] - s_y_pred) / np.linalg.norm(u_test[::P_test].flatten()[:,None]) "
      ],
      "metadata": {
        "id": "0-l8xC6cmjXv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(error_s,error_u)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T3OBppzUqMsa",
        "outputId": "4d76408a-289f-4d67-ca90-37ab1b1c2330"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.0032171660653468825 0.0037788479\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Visualize the results for the first function in our Testing Dataset"
      ],
      "metadata": {
        "id": "os7XSd21Xj3l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "idx=0\n",
        "index = np.arange(idx * P_test,(idx + 1) * P_test)"
      ],
      "metadata": {
        "id": "rxObn9b8sNFI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Compute the relative l2 error for one input sample \n",
        "error_u = np.linalg.norm(s_test[index, :] - s_pred[index, :], 2) / np.linalg.norm(s_test[index, :], 2) \n",
        "error_s = np.linalg.norm(u_test[::P_test][idx].flatten()[:,None] - s_y_pred[index, :], 2) / np.linalg.norm(u_test[::P_test][idx].flatten()[:,None], 2) \n",
        "\n",
        "print(\"error_u: {:.3e}\".format(error_u))\n",
        "print(\"error_s: {:.3e}\".format(error_s))\n",
        "\n",
        "# Visualizations\n",
        "# Predicted solution s(y)\n",
        "plt.figure(figsize=(12,5))\n",
        "plt.subplot(1,2,1)\n",
        "plt.plot(y_test[index, :], s_test[index, :], label='Exact s', lw=2)\n",
        "plt.plot(y_test[index, :], s_pred[index, :], '--', label='Predicted s', lw=2)\n",
        "plt.xlabel('y')\n",
        "plt.ylabel('s(y)')\n",
        "plt.tight_layout()\n",
        "plt.legend()\n",
        "\n",
        "plt.subplot(1,2,2)\n",
        "plt.plot(y_test[index, :], s_pred[index, :] - s_test[index, :], '--', lw=2, label='error')\n",
        "plt.tight_layout()\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "# Predicted residual u(x)\n",
        "fig = plt.figure(figsize=(12,5))\n",
        "plt.subplot(1,2,1)\n",
        "plt.plot(y_test[index, :], u_test[::P_test][idx], label='Exact u', lw=2)\n",
        "plt.plot(y_test[index, :], s_y_pred[index,:], '--', label='Predicted u', lw=2)\n",
        "plt.legend()\n",
        "plt.tight_layout()\n",
        "\n",
        "plt.subplot(1,2,2)\n",
        "plt.plot(y_test[index, :], s_y_pred[index,:].flatten() - u_test[::P_test][idx] , '--', label='error', lw=2)\n",
        "plt.legend()\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 723
        },
        "id": "IJs6uuFKsZav",
        "outputId": "4c9eaa06-0b66-436f-8344-a8a247eb8f7a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "error_u: 3.217e-03\n",
            "error_s: 3.779e-03\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x360 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x360 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Example"
      ],
      "metadata": {
        "id": "V2Tj3ENYAS1f"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lets obtain the anti-derivative of a trigonometric function. **However**, remember that this neural operator works for $x\\in[0,1]$ when the antiderivative's initial value ($s(0)=0$). To fulfill that conditions, we will use $u(x)=cos(2\\pi x),∀x\\in[0,1]$.\n",
        "\n",
        "\n",
        "So, we will evaluate our operator ($G$):\n",
        "\n",
        "\n",
        "$$G:u(x)→s(x)=s(0)+\\int_{0}^{x}u(t)dt$$\n",
        "\n",
        "to $u(t)=cos(2\\pi t)$:\n",
        "\n",
        "$$s(x)=s(0)+\\int_{0}^{x}cos(2\\pi t)dt$$\n",
        "\n",
        "Since $s(0)=0$, the answer would be (the integral of u):\n",
        "\n",
        "$$s(x)=\\frac{1}{2\\pi}sin(2\\pi x)$$\n",
        "\n"
      ],
      "metadata": {
        "id": "I9D9TlZpXvVS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#u_fn = lambda x, t: np.interp(t, X.flatten(), gp_sample)\n",
        "u_fn = lambda t, x: -np.cos(2*np.pi*x)\n",
        "# Input sensor locations and measurements\n",
        "x = np.linspace(0, 1, m)\n",
        "u = u_fn(None,x)\n",
        "# Output sensor locations and measurements\n",
        "y =random.uniform(key_train, (m,)).sort()"
      ],
      "metadata": {
        "id": "uBbYSKUGAJU1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# reshapte the data to be processed by our DeepOnet\n",
        "u2=np.tile(u,100)\n",
        "u2=np.float32(u2.reshape(N_test * P_test,-1))\n",
        "y=y.reshape(len(y),1)"
      ],
      "metadata": {
        "id": "5FrbAxKkALIi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s=model.predict_s(params, u2, y)[:,None]"
      ],
      "metadata": {
        "id": "Hg6jY2IbANDO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot_us(x,u,y,s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 406
        },
        "id": "J13kyBSwAO9X",
        "outputId": "e221a553-1775-4907-cf33-d28dcdf7a5fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# References\n",
        "\n",
        "[1] Lu, L., Jin, P., & Karniadakis, G. E. (2019). Deeponet: Learning nonlinear operators for identifying differential equations based on the universal approximation theorem of operators. arXiv preprint arXiv:1910.03193.\n",
        "\n",
        "[2] Wang, S., Wang, H., & Perdikaris, P. (2021). Learning the solution operator of parametric partial differential equations with physics-informed DeepONets. Science advances, 7(40), eabi8605."
      ],
      "metadata": {
        "id": "hAmGDh9OfSQd"
      }
    }
  ]
}
